gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), display_entry);
gtk_widget_grab_focus (display_entry);
- gtk_widget_show_all (GTK_BIN (dialog)->child);
+ gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (dialog)));
while (!result)
{
entry = g_object_new (TYPE_MASK_ENTRY, NULL);
MASK_ENTRY (entry)->mask = "^([0-9]*|One|Two|2\302\275|Three)$";
- gtk_container_remove (GTK_CONTAINER (combo), GTK_BIN (combo)->child);
+ gtk_container_remove (GTK_CONTAINER (combo), gtk_bin_get_child (GTK_BIN (combo)));
gtk_container_add (GTK_CONTAINER (combo), entry);
}
{
GtkWidget *widget;
GtkWidget *align;
+ GtkWidget *child;
gtk_rc_parse_string ("style \"combo-box-entry-style\" {\n"
" GtkComboBox::appears-as-list = 1\n"
"}\n"
"widget_class \"GtkComboBoxEntry\" style \"combo-box-entry-style\"\n" );
widget = gtk_combo_box_entry_new_text ();
- gtk_entry_set_text (GTK_ENTRY (GTK_BIN (widget)->child), "Combo Box Entry");
+ child = gtk_bin_get_child (GTK_BIN (widget));
+ gtk_entry_set_text (GTK_ENTRY (child), "Combo Box Entry");
align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
gtk_container_add (GTK_CONTAINER (align), widget);
gfloat xscale,
gfloat yscale)
{
+ GtkWidget *child;
+
g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
xalign = CLAMP (xalign, 0.0, 1.0);
}
g_object_thaw_notify (G_OBJECT (alignment));
- if (GTK_BIN (alignment)->child)
- gtk_widget_queue_resize (GTK_BIN (alignment)->child);
+ child = gtk_bin_get_child (GTK_BIN (alignment));
+ if (child)
+ gtk_widget_queue_resize (child);
gtk_widget_queue_draw (GTK_WIDGET (alignment));
}
}
GtkAlignment *alignment;
GtkBin *bin;
GtkAllocation child_allocation;
+ GtkWidget *bin_child;
gint width, height;
guint border_width;
gint padding_horizontal, padding_vertical;
widget->allocation = *allocation;
alignment = GTK_ALIGNMENT (widget);
bin = GTK_BIN (widget);
-
- if (bin->child && gtk_widget_get_visible (bin->child))
+
+ bin_child = gtk_bin_get_child (bin);
+ if (bin_child && gtk_widget_get_visible (bin_child))
{
- GtkSizeRequest *child = GTK_SIZE_REQUEST (bin->child);
+ GtkSizeRequest *child = GTK_SIZE_REQUEST (bin_child);
gint child_nat_width;
gint child_nat_height;
gint child_width, child_height;
child_allocation.y = alignment->yalign * (height - child_allocation.height) + allocation->y + border_width + priv->padding_top;
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (bin_child, &child_allocation);
}
}
guint padding_right)
{
GtkAlignmentPrivate *priv;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_ALIGNMENT (alignment));
g_object_thaw_notify (G_OBJECT (alignment));
/* Make sure that the widget and children are redrawn with the new setting: */
- if (GTK_BIN (alignment)->child)
- gtk_widget_queue_resize (GTK_BIN (alignment)->child);
+ child = gtk_bin_get_child (GTK_BIN (alignment));
+ if (child)
+ gtk_widget_queue_resize (child);
gtk_widget_queue_draw (GTK_WIDGET (alignment));
}
GtkAspectFrame *aspect_frame = GTK_ASPECT_FRAME (frame);
GtkAspectFramePriv *priv = aspect_frame->priv;
GtkBin *bin = GTK_BIN (frame);
+ GtkWidget *child;
gdouble ratio;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
GtkAllocation full_allocation;
{
GtkRequisition child_requisition;
- gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ gtk_widget_get_child_requisition (child, &child_requisition);
if (child_requisition.height != 0)
{
ratio = ((gdouble) child_requisition.width /
static GType
gtk_button_child_type (GtkContainer *container)
{
- if (!GTK_BIN (container)->child)
+ if (!gtk_bin_get_child (GTK_BIN (container)))
return GTK_TYPE_WIDGET;
else
return G_TYPE_NONE;
activatable_update_short_label (GtkButton *button,
GtkAction *action)
{
+ GtkWidget *child;
GtkWidget *image;
if (gtk_button_get_use_stock (button))
image = gtk_button_get_image (button);
/* Dont touch custom child... */
+ child = gtk_bin_get_child (GTK_BIN (button));
if (GTK_IS_IMAGE (image) ||
- GTK_BIN (button)->child == NULL ||
- GTK_IS_LABEL (GTK_BIN (button)->child))
+ child == NULL ||
+ GTK_IS_LABEL (child))
{
gtk_button_set_label (button, gtk_action_get_short_label (action));
gtk_button_set_use_underline (button, TRUE);
{
GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (button);
GtkStockItem item;
+ GtkWidget *child;
GtkWidget *label;
GtkWidget *box;
GtkWidget *align;
priv->image = NULL;
- if (GTK_BIN (button)->child)
- gtk_container_remove (GTK_CONTAINER (button),
- GTK_BIN (button)->child);
+ child = gtk_bin_get_child (GTK_BIN (button));
+ if (child)
+ gtk_container_remove (GTK_CONTAINER (button), child);
if (button->use_stock &&
button->label_text &&
if (!button->constructed || !priv->image)
return;
- child = GTK_BIN (button)->child;
+ child = gtk_bin_get_child (GTK_BIN (button));
if (GTK_IS_ALIGNMENT (child))
{
- child = GTK_BIN (child)->child;
+ child = gtk_bin_get_child (GTK_BIN (child));
if (GTK_IS_BOX (child))
{
gtk_widget_style_get (GTK_WIDGET (button),
{
GtkButton *button = GTK_BUTTON (widget);
GtkAllocation child_allocation;
+ GtkWidget *child;
guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
gint xthickness = GTK_WIDGET (widget)->style->xthickness;
widget->allocation.width - border_width * 2,
widget->allocation.height - border_width * 2);
- if (GTK_BIN (button)->child && gtk_widget_get_visible (GTK_BIN (button)->child))
+ child = gtk_bin_get_child (GTK_BIN (button));
+ if (child && gtk_widget_get_visible (child))
{
child_allocation.x = widget->allocation.x + border_width + inner_border.left + xthickness;
child_allocation.y = widget->allocation.y + border_width + inner_border.top + ythickness;
child_allocation.y += child_displacement_y;
}
- gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
}
priv->yalign = yalign;
priv->align_set = 1;
- maybe_set_alignment (button, GTK_BIN (button)->child);
+ maybe_set_alignment (button, gtk_bin_get_child (GTK_BIN (button)));
g_object_freeze_notify (G_OBJECT (button));
g_object_notify (G_OBJECT (button), "xalign");
g_object_get (cell_text, "text", &text, NULL);
if (text)
- gtk_entry_set_text (GTK_ENTRY (GTK_BIN (combo)->child),
+ gtk_entry_set_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo))),
text);
g_free (text);
}
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
if (gtk_widget_has_focus (widget))
{
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
if (interior_focus && child && gtk_widget_get_visible (child))
gtk_paint_focus (widget->style, widget->window, gtk_widget_get_state (widget),
_gtk_check_button_get_props (GTK_CHECK_BUTTON (widget),
&indicator_size, &indicator_spacing);
- child = GTK_BIN (widget)->child;
+ child = gtk_bin_get_child (GTK_BIN (widget));
if (child && gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
if (toggle_button->draw_indicator)
{
+ GtkWidget *child;
gint indicator_size;
gint indicator_spacing;
gint focus_width;
gdk_window_move_resize (button->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
-
- if (GTK_BIN (button)->child && gtk_widget_get_visible (GTK_BIN (button)->child))
+
+ child = gtk_bin_get_child (GTK_BIN (button));
+ if (child && gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
- gtk_widget_get_child_requisition (GTK_BIN (button)->child, &child_requisition);
+ gtk_widget_get_child_requisition (child, &child_requisition);
child_allocation.width = MIN (child_requisition.width,
allocation->width -
child_allocation.x = allocation->x + allocation->width
- (child_allocation.x - allocation->x + child_allocation.width);
- gtk_widget_size_allocate (GTK_BIN (button)->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
}
else
{
GtkToggleButton *toggle_button;
GtkBin *bin;
+ GtkWidget *child;
toggle_button = GTK_TOGGLE_BUTTON (widget);
bin = GTK_BIN (widget);
if (toggle_button->draw_indicator)
{
gtk_check_button_paint (widget, &event->area);
-
- if (bin->child)
+
+ child = gtk_bin_get_child (bin);
+ if (child)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
- bin->child,
+ child,
event);
}
else if (GTK_WIDGET_CLASS (gtk_check_button_parent_class)->expose_event)
x = widget->allocation.x + indicator_spacing + border_width;
y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2;
- child = GTK_BIN (check_button)->child;
+ child = gtk_bin_get_child (GTK_BIN (check_button));
if (!interior_focus || !(child && gtk_widget_get_visible (child)))
x += focus_width + focus_pad;
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
gtk_combo_box_check_appearance (combo_box);
gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
&widget->style->base[gtk_widget_get_state (widget)]);
- if (GTK_IS_ENTRY (GTK_BIN (combo_box)->child))
- g_object_set (GTK_BIN (combo_box)->child, "shadow-type",
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+ if (GTK_IS_ENTRY (child))
+ g_object_set (child, "shadow-type",
GTK_SHADOW_NONE == priv->shadow_type ?
GTK_SHADOW_IN : GTK_SHADOW_NONE, NULL);
}
GdkRectangle monitor;
/* FIXME: is using the size request here broken? */
- child = GTK_BIN (combo_box)->child;
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
sx = sy = 0;
for (child = children; child; child = child->next)
{
item = GTK_WIDGET (child->data);
- cell_view = GTK_BIN (item)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (item));
if (!GTK_IS_CELL_VIEW (cell_view))
continue;
GtkComboBoxPrivate *priv = combo_box->priv;
/* common */
- gtk_widget_size_request (GTK_BIN (widget)->child, &bin_req);
+ gtk_widget_size_request (gtk_bin_get_child (GTK_BIN (widget)), &bin_req);
gtk_combo_box_remeasure (combo_box);
bin_req.width = MAX (bin_req.width, priv->width);
bin_req.height = MAX (bin_req.height, priv->height);
"arrow-size", &arrow_size,
NULL);
- font_desc = GTK_BIN (widget)->child->style->font_desc;
+ font_desc = gtk_bin_get_child (GTK_BIN (widget))->style->font_desc;
context = gtk_widget_get_pango_context (widget);
metrics = pango_context_get_metrics (context, font_desc,
pango_context_get_language (context));
{
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child_widget;
gint shadow_width, shadow_height;
gint focus_width, focus_pad;
GtkAllocation child;
gboolean is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
widget->allocation = *allocation;
+ child_widget = gtk_bin_get_child (GTK_BIN (widget));
gtk_widget_style_get (GTK_WIDGET (widget),
"focus-line-width", &focus_width,
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (widget)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
else
{
child.width = allocation->width - req.width - 2 * shadow_width;
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (widget)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
}
else
child.width = MAX (1, child.width);
child.height = MAX (1, child.height);
- gtk_widget_size_allocate (GTK_BIN (combo_box)->child, &child);
+ gtk_widget_size_allocate (child_widget, &child);
}
}
{
GtkComboBox *combo_box = GTK_COMBO_BOX (container);
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
if (include_internals)
{
(* callback) (priv->cell_view_frame, callback_data);
}
- if (GTK_BIN (container)->child)
- (* callback) (GTK_BIN (container)->child, callback_data);
+ child = gtk_bin_get_child (GTK_BIN (container));
+ if (child)
+ (* callback) (child, callback_data);
}
static void
}
gtk_container_propagate_expose (GTK_CONTAINER (widget),
- GTK_BIN (widget)->child, event);
+ gtk_bin_get_child (GTK_BIN (widget)),
+ event);
return FALSE;
}
gboolean add_children)
{
GtkComboBoxPrivate *priv = combo_box->priv;
+ GtkWidget *child;
GtkWidget *menu;
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
if (priv->cell_view)
{
priv->button = gtk_toggle_button_new ();
g_signal_connect (priv->button, "toggled",
G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
priv->box = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (priv->button), priv->box);
g_signal_connect (priv->button, "toggled",
G_CALLBACK (gtk_combo_box_button_toggled), combo_box);
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
priv->arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (priv->button), priv->arrow);
GtkTreePath *path;
GtkTreeIter iter;
- cell_view = GTK_BIN (item)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (item));
g_return_if_fail (GTK_IS_CELL_VIEW (cell_view));
gboolean skip_first)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *item;
GtkWidget *submenu;
GtkTreeRowReference *mref;
item = NULL;
for (i = list; i; i = i->next)
{
+ child = gtk_bin_get_child (i->data);
if (GTK_IS_SEPARATOR_MENU_ITEM (i->data))
{
mref = g_object_get_data (G_OBJECT (i->data), "gtk-combo-box-item-path");
else
mpath = gtk_tree_row_reference_get_path (mref);
}
- else if (GTK_IS_CELL_VIEW (GTK_BIN (i->data)->child))
+ else if (GTK_IS_CELL_VIEW (child))
{
if (skip)
{
continue;
}
- mpath = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (GTK_BIN (i->data)->child));
+ mpath = gtk_cell_view_get_displayed_row (GTK_CELL_VIEW (child));
}
else
continue;
combo_box);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
- if (cell_view_is_sensitive (GTK_CELL_VIEW (GTK_BIN (item)->child)))
+ if (cell_view_is_sensitive (GTK_CELL_VIEW (gtk_bin_get_child (GTK_BIN (item)))))
{
gtk_widget_show (item);
gtk_widget_show (separator);
GtkComboBoxPrivate *priv = combo_box->priv;
GtkTreeSelection *sel;
GtkStyle *style;
+ GtkWidget *child;
GtkWidget *widget = GTK_WIDGET (combo_box);
priv->button = gtk_toggle_button_new ();
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
gtk_widget_set_parent (priv->button,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
g_signal_connect (priv->button, "button-press-event",
G_CALLBACK (gtk_combo_box_list_button_pressed), combo_box);
g_signal_connect (priv->button, "toggled",
gtk_event_box_set_visible_window (GTK_EVENT_BOX (combo_box->priv->cell_view_frame),
FALSE);
}
-
+
gtk_widget_set_parent (priv->cell_view_frame,
- GTK_BIN (combo_box)->child->parent);
+ gtk_widget_get_parent (child));
gtk_container_add (GTK_CONTAINER (priv->cell_view_frame), priv->box);
gtk_widget_show_all (priv->cell_view_frame);
gboolean expand)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, expand);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (child),
+ cell, expand);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
gboolean expand)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, expand);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (child),
+ cell, expand);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
clear_recurse (GtkWidget *menu)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_clear (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child));
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_clear (GTK_CELL_LAYOUT (child));
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
gint column)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
-
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, attribute, column);
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (child),
+ cell, attribute, column);
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- cell_view = GTK_BIN (i->data)->child;
+ cell_view = gtk_bin_get_child (GTK_BIN (i->data));
if (GTK_IS_CELL_LAYOUT (cell_view))
{
/* Override sensitivity for inner nodes; we don't
GtkCellRenderer *cell)
{
GList *i, *list;
- GtkWidget *submenu;
-
+ GtkWidget *submenu;
+ GtkWidget *child;
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell);
-
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_clear_attributes (GTK_CELL_LAYOUT (child), cell);
+
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
clear_attributes_recurse (submenu, cell);
gint position)
{
GList *i, *list;
+ GtkWidget *child;
GtkWidget *submenu;
-
+
list = gtk_container_get_children (GTK_CONTAINER (menu));
for (i = list; i; i = i->next)
{
- if (GTK_IS_CELL_LAYOUT (GTK_BIN (i->data)->child))
- gtk_cell_layout_reorder (GTK_CELL_LAYOUT (GTK_BIN (i->data)->child),
- cell, position);
-
+ child = gtk_bin_get_child (GTK_BIN (i->data));
+ gtk_cell_layout_reorder (GTK_CELL_LAYOUT (child),
+ cell, position);
+
submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (i->data));
if (submenu != NULL)
reorder_recurse (submenu, cell, position);
GdkEvent *event)
{
GtkComboBox *combo_box = GTK_COMBO_BOX (cell_editable);
+ GtkWidget *child;
combo_box->priv->is_cell_renderer = TRUE;
}
else
{
- g_signal_connect_object (GTK_BIN (combo_box)->child, "key-press-event",
+ child = gtk_bin_get_child (GTK_BIN (combo_box));
+
+ g_signal_connect_object (child, "key-press-event",
G_CALLBACK (gtk_cell_editable_key_press),
cell_editable, 0);
- gtk_widget_grab_focus (GTK_WIDGET (GTK_BIN (combo_box)->child));
+ gtk_widget_grab_focus (child);
gtk_widget_set_can_focus (combo_box->priv->button, FALSE);
}
gtk_combo_box_entry_remove (GtkContainer *container,
GtkWidget *child)
{
- if (child && child == GTK_BIN (container)->child)
+ GtkWidget *child_widget;
+
+ child_widget = gtk_bin_get_child (GTK_BIN (container));
+ if (child && child == child_widget)
{
g_signal_handlers_disconnect_by_func (child,
gtk_combo_box_entry_contents_changed,
if (gtk_combo_box_get_active_iter (combo_box, &iter))
{
- GtkEntry *entry = GTK_ENTRY (GTK_BIN (combo_box)->child);
+ GtkEntry *entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (combo_box)));
if (entry)
{
GParamSpec *pspec,
gpointer data)
{
- if (GTK_BIN (entry_box)->child)
+ GtkWidget *child;
+
+ child = gtk_bin_get_child (GTK_BIN (entry_box));
+ if (child)
{
gboolean has_frame;
g_object_get (entry_box, "has-frame", &has_frame, NULL);
- gtk_entry_set_has_frame (GTK_ENTRY (GTK_BIN (entry_box)->child), has_frame);
+ gtk_entry_set_has_frame (GTK_ENTRY (child), has_frame);
}
}
gboolean group_cycling)
{
GtkBin *entry_box = GTK_BIN (widget);
+ GtkWidget* child;
- if (entry_box->child)
- gtk_widget_grab_focus (entry_box->child);
+ child = gtk_bin_get_child (entry_box);
+ if (child)
+ gtk_widget_grab_focus (child);
return TRUE;
}
gtk_combo_box_entry_grab_focus (GtkWidget *widget)
{
GtkBin *entry_box = GTK_BIN (widget);
+ GtkWidget *child;
- if (entry_box->child)
- gtk_widget_grab_focus (entry_box->child);
+ child = gtk_bin_get_child (entry_box);
+ if (child)
+ gtk_widget_grab_focus (child);
}
gtk_combo_box_entry_get_active_text (GtkComboBox *combo_box)
{
GtkBin *combo = GTK_BIN (combo_box);
+ GtkWidget *child;
- if (combo->child)
- return g_strdup (gtk_entry_get_text (GTK_ENTRY (combo->child)));
+ child = gtk_bin_get_child (combo);
+ if (child)
+ return g_strdup (gtk_entry_get_text (GTK_ENTRY (child)));
return NULL;
}
{
GtkBin *bin = GTK_BIN (widget);
guint border_width;
+ GtkWidget *child;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
requisition->width = border_width * 2;
requisition->height = border_width * 2;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
- gtk_widget_size_request (bin->child, &child_requisition);
+ gtk_widget_size_request (child, &child_requisition);
requisition->width += child_requisition.width;
requisition->height += child_requisition.height;
GtkAllocation child_allocation;
GtkEventBoxPrivate *priv;
guint border_width;
-
+ GtkWidget *child;
+
widget->allocation = *allocation;
bin = GTK_BIN (widget);
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
child_allocation.width,
child_allocation.height);
}
-
- if (bin->child)
- gtk_widget_size_allocate (bin->child, &child_allocation);
+
+ child = gtk_bin_get_child (bin);
+ if (child)
+ gtk_widget_size_allocate (child, &child_allocation);
}
static void
GtkExpander *expander;
GtkBin *bin;
GtkExpanderPrivate *priv;
+ GtkWidget *child;
gint border_width;
gint expander_size;
gint expander_spacing;
if (!interior_focus)
requisition->height += 2 * focus_width + 2 * focus_pad;
- if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && GTK_WIDGET_CHILD_VISIBLE (child))
{
GtkRequisition child_requisition;
- gtk_widget_size_request (bin->child, &child_requisition);
+ gtk_widget_size_request (child, &child_requisition);
requisition->width = MAX (requisition->width, child_requisition.width);
requisition->height += child_requisition.height + priv->spacing;
GtkBin *bin;
GtkExpanderPrivate *priv;
GtkRequisition child_requisition;
+ GtkWidget *child;
gboolean child_visible = FALSE;
guint border_width;
gint expander_size;
child_requisition.width = 0;
child_requisition.height = 0;
- if (bin->child && GTK_WIDGET_CHILD_VISIBLE (bin->child))
+
+ child = gtk_bin_get_child (bin);
+ if (child && GTK_WIDGET_CHILD_VISIBLE (child))
{
child_visible = TRUE;
- gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ gtk_widget_get_child_requisition (child, &child_requisition);
}
widget->allocation = *allocation;
(!interior_focus ? 2 * focus_width + 2 * focus_pad : 0);
child_allocation.height = MAX (child_allocation.height, 1);
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
}
{
GtkBin *bin = GTK_BIN (container);
GtkExpanderPrivate *priv = GTK_EXPANDER (container)->priv;
+ GtkWidget *child;
- if (bin->child)
- (* callback) (bin->child, callback_data);
+ child = gtk_bin_get_child (bin);
+ if (child)
+ (* callback) (child, callback_data);
if (priv->label_widget)
(* callback) (priv->label_widget, callback_data);
gtk_expander_animation_timeout (GtkExpander *expander)
{
GtkExpanderPrivate *priv = expander->priv;
+ GtkWidget *child;
GdkRectangle area;
gboolean finish = FALSE;
if (finish)
{
priv->animation_timeout = 0;
- if (GTK_BIN (expander)->child)
- gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
+
+ child = gtk_bin_get_child (GTK_BIN (expander));
+ if (child)
+ gtk_widget_set_child_visible (child, priv->expanded);
gtk_widget_queue_resize (GTK_WIDGET (expander));
}
gboolean expanded)
{
GtkExpanderPrivate *priv;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_EXPANDER (expander));
priv->expander_style = expanded ? GTK_EXPANDER_EXPANDED :
GTK_EXPANDER_COLLAPSED;
- if (GTK_BIN (expander)->child)
+ child = gtk_bin_get_child (GTK_BIN (expander));
+ if (child)
{
- gtk_widget_set_child_visible (GTK_BIN (expander)->child, priv->expanded);
+ gtk_widget_set_child_visible (child, priv->expanded);
gtk_widget_queue_resize (GTK_WIDGET (expander));
}
}
{
GtkBin *bin = GTK_BIN (container);
GtkFrame *frame = GTK_FRAME (container);
+ GtkWidget *child;
- if (bin->child)
- (* callback) (bin->child, callback_data);
+ child = gtk_bin_get_child (bin);
+ if (child)
+ (* callback) (child, callback_data);
if (frame->label_widget)
(* callback) (frame->label_widget, callback_data);
GtkFrame *frame = GTK_FRAME (widget);
GtkBin *bin = GTK_BIN (widget);
GtkAllocation new_allocation;
+ GtkWidget *child;
widget->allocation = *allocation;
#endif
)
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
-
- if (bin->child && gtk_widget_get_visible (bin->child))
- gtk_widget_size_allocate (bin->child, &new_allocation);
+
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
+ gtk_widget_size_allocate (child, &new_allocation);
frame->child_allocation = new_allocation;
gint *natural_size)
{
GtkWidget *widget = GTK_WIDGET (request);
+ GtkWidget *child;
GtkFrame *frame = GTK_FRAME (widget);
GtkBin *bin = GTK_BIN (widget);
gint child_min, child_nat;
natural = 0;
}
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
- gtk_size_request_get_width (GTK_SIZE_REQUEST (bin->child),
+ gtk_size_request_get_width (GTK_SIZE_REQUEST (child),
&child_min, &child_nat);
minimum = MAX (minimum, child_min);
natural = MAX (natural, child_nat);
}
else
{
- gtk_size_request_get_height (GTK_SIZE_REQUEST (bin->child),
+ gtk_size_request_get_height (GTK_SIZE_REQUEST (child),
&child_min, &child_nat);
minimum += child_min;
natural += child_nat;
{
GtkBin *bin;
GtkHandleBox *hb;
+ GtkWidget *child;
gtk_widget_set_mapped (widget, TRUE);
bin = GTK_BIN (widget);
hb = GTK_HANDLE_BOX (widget);
- if (bin->child &&
- gtk_widget_get_visible (bin->child) &&
- !gtk_widget_get_mapped (bin->child))
- gtk_widget_map (bin->child);
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child) &&
+ !gtk_widget_get_mapped (child))
+ gtk_widget_map (child);
if (hb->child_detached && !hb->float_window_mapped)
{
static void
gtk_handle_box_realize (GtkWidget *widget)
{
+ GtkHandleBox *hb;
+ GtkWidget *child;
GdkWindowAttr attributes;
gint attributes_mask;
- GtkHandleBox *hb;
hb = GTK_HANDLE_BOX (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
hb->bin_window = gdk_window_new (widget->window, &attributes, attributes_mask);
gdk_window_set_user_data (hb->bin_window, widget);
- if (GTK_BIN (hb)->child)
- gtk_widget_set_parent_window (GTK_BIN (hb)->child, hb->bin_window);
+
+ child = gtk_bin_get_child (GTK_BIN (hb));
+ if (child)
+ gtk_widget_set_parent_window (child, hb->bin_window);
attributes.x = 0;
attributes.y = 0;
GtkBin *bin;
GtkHandleBox *hb;
GtkRequisition child_requisition;
+ GtkWidget *child;
gint handle_position;
bin = GTK_BIN (widget);
requisition->height = DRAG_HANDLE_SIZE;
}
+ child = gtk_bin_get_child (bin);
/* if our child is not visible, we still request its size, since we
* won't have any useful hint for our size otherwise.
*/
- if (bin->child)
- gtk_widget_size_request (bin->child, &child_requisition);
+ if (child)
+ gtk_widget_size_request (child, &child_requisition);
else
{
child_requisition.width = 0;
requisition->width += border_width * 2;
requisition->height += border_width * 2;
- if (bin->child)
+ if (child)
{
requisition->width += child_requisition.width;
requisition->height += child_requisition.height;
GtkBin *bin;
GtkHandleBox *hb;
GtkRequisition child_requisition;
+ GtkWidget *child;
gint handle_position;
bin = GTK_BIN (widget);
handle_position = effective_handle_position (hb);
- if (bin->child)
- gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ child = gtk_bin_get_child (bin);
+
+ if (child)
+ gtk_widget_get_child_requisition (child, &child_requisition);
else
{
child_requisition.width = 0;
widget->allocation.height);
- if (bin->child && gtk_widget_get_visible (bin->child))
+ if (gtk_widget_get_visible (child))
{
GtkAllocation child_allocation;
guint border_width;
widget->allocation.height);
}
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
}
event ? &event->area : area,
handle_orientation);
- if (bin->child && gtk_widget_get_visible (bin->child))
+ if (gtk_widget_get_visible (gtk_bin_get_child (bin)))
GTK_WIDGET_CLASS (gtk_handle_box_parent_class)->expose_event (widget, event);
}
if (event->window != hb->bin_window)
return FALSE;
- child = GTK_BIN (hb)->child;
+ child = gtk_bin_get_child (GTK_BIN (hb));
if (child)
{
GdkEventMotion *event)
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
+ GtkWidget *child;
gint new_x, new_y;
gint snap_edge;
gboolean is_snapped = FALSE;
(float_pos2 + TOLERANCE > attach_pos2));
}
+ child = gtk_bin_get_child (GTK_BIN (hb));
+
if (is_snapped)
{
if (hb->child_detached)
g_signal_emit (hb,
handle_box_signals[SIGNAL_CHILD_ATTACHED],
0,
- GTK_BIN (hb)->child);
+ child);
gtk_widget_queue_resize (widget);
}
hb->child_detached = TRUE;
- if (GTK_BIN (hb)->child)
- gtk_widget_get_child_requisition (GTK_BIN (hb)->child, &child_requisition);
+ if (child)
+ gtk_widget_get_child_requisition (child, &child_requisition);
else
{
child_requisition.width = 0;
g_signal_emit (hb,
handle_box_signals[SIGNAL_CHILD_DETACHED],
0,
- GTK_BIN (hb)->child);
+ child);
gtk_handle_box_draw_ghost (hb);
gtk_widget_queue_resize (widget);
static void
gtk_handle_box_reattach (GtkHandleBox *hb)
{
+ GtkWidget *child;
GtkWidget *widget = GTK_WIDGET (hb);
if (hb->child_detached)
gdk_window_hide (hb->float_window);
gdk_window_reparent (hb->bin_window, widget->window, 0, 0);
- if (GTK_BIN (hb)->child)
+ child = gtk_bin_get_child (GTK_BIN (hb));
+ if (child)
g_signal_emit (hb,
handle_box_signals[SIGNAL_CHILD_ATTACHED],
0,
- GTK_BIN (hb)->child);
+ child);
}
hb->float_window_mapped = FALSE;
{
gtk_widget_set_size_request (menu->tearoff_window, -1, -1);
- if (GTK_BIN (menu->toplevel)->child)
+ if (gtk_bin_get_child (GTK_BIN (menu->toplevel)))
{
gtk_menu_reparent (menu, menu->tearoff_hbox, TRUE);
}
child = children->data;
children = children->next;
- if (GTK_BIN (child)->child)
+ if (gtk_bin_get_child (GTK_BIN (child)))
break;
child = NULL;
}
if (tmp_list)
{
child = tmp_list->data;
- if (GTK_BIN (child)->child)
+ if (gtk_bin_get_child (GTK_BIN (child)))
{
if (menu->old_active_menu_item)
g_object_unref (menu->old_active_menu_item);
attach_widget = gtk_menu_get_attach_widget (menu);
if (GTK_IS_MENU_ITEM (attach_widget))
{
- GtkWidget *child = GTK_BIN (attach_widget)->child;
+ GtkWidget *child = gtk_bin_get_child (GTK_BIN (attach_widget));
if (GTK_IS_LABEL (child))
title = gtk_label_get_text (GTK_LABEL (child));
}
{
*locked = TRUE;
- label = GTK_BIN (menu_item)->child;
+ label = gtk_bin_get_child (GTK_BIN (menu_item));
if (GTK_IS_ACCEL_LABEL (label))
{
/* Modify the accelerators */
if (can_change_accels &&
menu_shell->active_menu_item &&
- GTK_BIN (menu_shell->active_menu_item)->child && /* no separators */
+ gtk_bin_get_child (GTK_BIN (menu_shell->active_menu_item)) && /* no separators */
GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu == NULL && /* no submenus */
(delete || gtk_accelerator_valid (accel_key, accel_mods)))
{
static void
activatable_update_label (GtkMenuItem *menu_item, GtkAction *action)
{
- GtkWidget *child = GTK_BIN (menu_item)->child;
+ GtkWidget *child;
+
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
if (GTK_IS_LABEL (child))
{
{
GtkMenuItem *menu_item = GTK_MENU_ITEM (activatable);
GtkMenuItemPrivate *priv = GET_PRIVATE (menu_item);
+ GtkWidget *label;
if (!priv->use_action_appearance || !action)
{
- GtkWidget *label = GTK_BIN (menu_item)->child;
-
- label = GTK_BIN (menu_item)->child;
+ label = gtk_bin_get_child (GTK_BIN (menu_item));
if (GTK_IS_ACCEL_LABEL (label))
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), GTK_WIDGET (menu_item));
if (priv->use_action_appearance)
{
- GtkWidget *label = GTK_BIN (menu_item)->child;
+ label = gtk_bin_get_child (GTK_BIN (menu_item));
/* make sure label is a label */
if (label && !GTK_IS_LABEL (label))
gtk_menu_item_ensure_label (menu_item);
gtk_menu_item_set_use_underline (menu_item, TRUE);
- label = GTK_BIN (menu_item)->child;
-
if (GTK_IS_ACCEL_LABEL (label) && gtk_action_get_accel_path (action))
{
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), NULL);
{
GtkMenuItem *menu_item;
GtkBin *bin;
+ GtkWidget *child;
guint accel_width;
guint horizontal_padding;
guint border_width;
(child_pack_dir == GTK_PACK_DIRECTION_TTB || child_pack_dir == GTK_PACK_DIRECTION_BTT))
requisition->height += 2 * horizontal_padding;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
- gtk_widget_size_request (bin->child, &child_requisition);
+ gtk_widget_size_request (child, &child_requisition);
requisition->width += child_requisition.width;
requisition->height += child_requisition.height;
GtkTextDirection direction;
GtkPackDirection pack_dir;
GtkPackDirection child_pack_dir;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
g_return_if_fail (allocation != NULL);
widget->allocation = *allocation;
- if (bin->child)
+ child = gtk_bin_get_child (bin);
+ if (child)
{
GtkRequisition child_requisition;
guint horizontal_padding;
child_allocation.x += widget->allocation.x;
child_allocation.y += widget->allocation.y;
- gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ gtk_widget_get_child_requisition (child, &child_requisition);
if (menu_item->submenu && menu_item->show_submenu_indicator)
{
if (direction == GTK_TEXT_DIR_RTL)
if (child_allocation.width < 1)
child_allocation.width = 1;
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
if (gtk_widget_get_realized (widget))
GtkMenuItem *menu_item;
GtkStateType state_type;
GtkShadowType shadow_type, selected_shadow_type;
+ GtkWidget *child;
gint width, height;
gint x, y;
guint border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
y = widget->allocation.y + border_width;
width = widget->allocation.width - border_width * 2;
height = widget->allocation.height - border_width * 2;
+
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
- if ((state_type == GTK_STATE_PRELIGHT) &&
- (GTK_BIN (menu_item)->child))
+ if (child && state_type == GTK_STATE_PRELIGHT)
{
gtk_widget_style_get (widget,
"selected-shadow-type", &selected_shadow_type,
"arrow-scaling", &arrow_scaling,
NULL);
- context = gtk_widget_get_pango_context (GTK_BIN (menu_item)->child);
+ context = gtk_widget_get_pango_context (child);
metrics = pango_context_get_metrics (context,
- GTK_WIDGET (GTK_BIN (menu_item)->child)->style->font_desc,
+ child->style->font_desc,
pango_context_get_language (context));
arrow_size = (PANGO_PIXELS (pango_font_metrics_get_ascent (metrics) +
arrow_x, arrow_y,
arrow_extent, arrow_extent);
}
- else if (!GTK_BIN (menu_item)->child)
+ else if (!child)
{
gboolean wide_separators;
gint separator_height;
gtk_real_menu_item_set_label (GtkMenuItem *menu_item,
const gchar *label)
{
+ GtkWidget *child;
+
gtk_menu_item_ensure_label (menu_item);
- if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
+ if (GTK_IS_LABEL (child))
{
- gtk_label_set_label (GTK_LABEL (GTK_BIN (menu_item)->child), label ? label : "");
+ gtk_label_set_label (GTK_LABEL (child), label ? label : "");
g_object_notify (G_OBJECT (menu_item), "label");
}
static G_CONST_RETURN gchar *
gtk_real_menu_item_get_label (GtkMenuItem *menu_item)
{
+ GtkWidget *child;
+
gtk_menu_item_ensure_label (menu_item);
- if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
- return gtk_label_get_label (GTK_LABEL (GTK_BIN (menu_item)->child));
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
+ if (GTK_IS_LABEL (child))
+ return gtk_label_get_label (GTK_LABEL (child));
return NULL;
}
GtkCallback callback,
gpointer callback_data)
{
- GtkBin *bin;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_MENU_ITEM (container));
g_return_if_fail (callback != NULL);
- bin = GTK_BIN (container);
-
- if (bin->child)
- callback (bin->child, callback_data);
+ child = gtk_bin_get_child (GTK_BIN (container));
+ if (child)
+ callback (child, callback_data);
}
gboolean
_gtk_menu_item_is_selectable (GtkWidget *menu_item)
{
- if ((!GTK_BIN (menu_item)->child &&
+ if ((!gtk_bin_get_child (GTK_BIN (menu_item)) &&
G_OBJECT_TYPE (menu_item) == GTK_TYPE_MENU_ITEM) ||
GTK_IS_SEPARATOR_MENU_ITEM (menu_item) ||
!gtk_widget_is_sensitive (menu_item) ||
{
GtkWidget *accel_label;
- if (!GTK_BIN (menu_item)->child)
+ if (!gtk_bin_get_child (GTK_BIN (menu_item)))
{
accel_label = g_object_new (GTK_TYPE_ACCEL_LABEL, NULL);
gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
gtk_menu_item_set_use_underline (GtkMenuItem *menu_item,
gboolean setting)
{
+ GtkWidget *child;
+
g_return_if_fail (GTK_IS_MENU_ITEM (menu_item));
gtk_menu_item_ensure_label (menu_item);
- if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
+ if (GTK_IS_LABEL (child))
{
- gtk_label_set_use_underline (GTK_LABEL (GTK_BIN (menu_item)->child), setting);
+ gtk_label_set_use_underline (GTK_LABEL (child), setting);
g_object_notify (G_OBJECT (menu_item), "use-underline");
}
gboolean
gtk_menu_item_get_use_underline (GtkMenuItem *menu_item)
{
+ GtkWidget *child;
+
g_return_val_if_fail (GTK_IS_MENU_ITEM (menu_item), FALSE);
gtk_menu_item_ensure_label (menu_item);
-
- if (GTK_IS_LABEL (GTK_BIN (menu_item)->child))
- return gtk_label_get_use_underline (GTK_LABEL (GTK_BIN (menu_item)->child));
+
+ child = gtk_bin_get_child (GTK_BIN (menu_item));
+ if (GTK_IS_LABEL (child))
+ return gtk_label_get_use_underline (GTK_LABEL (child));
return FALSE;
}
box = gtk_hbox_new (FALSE, 0);
- real_button = GTK_BIN (button)->child;
+ real_button = gtk_bin_get_child (GTK_BIN (button));
g_object_ref (real_button);
gtk_container_remove (GTK_CONTAINER (button), real_button);
gtk_container_add (GTK_CONTAINER (box), real_button);
GdkEventExpose *event,
gpointer data)
{
- GtkWidget *notebook, *child = GTK_WIDGET (data);
+ GtkWidget *notebook, *child;
GtkRequisition requisition;
gint gap_pos;
notebook = GTK_WIDGET (data);
- child = GTK_BIN (widget)->child;
+ child = gtk_bin_get_child (GTK_BIN (widget));
+
gtk_widget_size_request (widget, &requisition);
gap_pos = get_tab_gap_pos (GTK_NOTEBOOK (notebook));
gtk_notebook_menu_label_unparent (GtkWidget *widget,
gpointer data)
{
- gtk_widget_unparent (GTK_BIN (widget)->child);
+ gtk_widget_unparent (gtk_bin_get_child (GTK_BIN (widget)));
GTK_BIN (widget)->child = NULL;
}
GtkRequisition *requisition)
{
GtkBin *bin = GTK_BIN (widget);
+ GtkWidget *child;
gint border_width;
gint default_width, default_height;
requisition->width = border_width * 2;
requisition->height = border_width * 2;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child))
{
GtkRequisition child_req;
- gtk_widget_size_request (bin->child, &child_req);
+ gtk_widget_size_request (child, &child_req);
requisition->width += child_req.width;
requisition->height += child_req.height;
GtkAllocation *allocation)
{
GtkBin *bin = GTK_BIN (widget);
+ GtkWidget *child;
gint border_width;
widget->allocation = *allocation;
allocation->width,
allocation->height);
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child))
{
GtkAllocation child_alloc;
child_alloc.width = allocation->width - 2 * border_width;
child_alloc.height = allocation->height - 2 * border_width;
- gtk_widget_size_allocate (bin->child, &child_alloc);
+ gtk_widget_size_allocate (child, &child_alloc);
}
gtk_widget_queue_draw (widget);
gtk_offscreen_window_realize (GtkWidget *widget)
{
GtkBin *bin;
+ GtkWidget *child;
GdkWindowAttr attributes;
gint attributes_mask;
gint border_width;
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, widget);
- if (bin->child)
- gtk_widget_set_parent_window (bin->child, widget->window);
+ child = gtk_bin_get_child (bin);
+ if (child)
+ gtk_widget_set_parent_window (child, widget->window);
widget->style = gtk_style_attach (widget->style, widget->window);
{
GtkBin *bin = GTK_BIN (widget);
GtkPlug *plug = GTK_PLUG (widget);
+ GtkWidget *child;
gtk_widget_set_mapped (widget, TRUE);
- if (bin->child &&
- gtk_widget_get_visible (bin->child) &&
- !gtk_widget_get_mapped (bin->child))
- gtk_widget_map (bin->child);
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child) &&
+ !gtk_widget_get_mapped (child))
+ gtk_widget_map (child);
_gtk_plug_windowing_map_toplevel (plug);
gtk_plug_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
+ GtkWidget *child;
+
if (gtk_widget_is_toplevel (widget))
GTK_WIDGET_CLASS (gtk_plug_parent_class)->size_allocate (widget, allocation);
else
allocation->x, allocation->y,
allocation->width, allocation->height);
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (gtk_widget_get_visible (child))
{
GtkAllocation child_allocation;
child_allocation.height =
MAX (1, (gint)allocation->height - child_allocation.y * 2);
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
}
GtkPlug *plug = GTK_PLUG (widget);
GtkWindow *window = GTK_WINDOW (widget);
GtkContainer *container = GTK_CONTAINER (widget);
+ GtkWidget *child;
GtkWidget *old_focus_child;
GtkWidget *parent;
else
{
/* Try to focus the first widget in the window */
- if (bin->child && gtk_widget_child_focus (bin->child, direction))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_child_focus (child, direction))
return TRUE;
}
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
table);
- gtk_viewport_set_shadow_type (GTK_VIEWPORT (GTK_BIN(scrolled)->child),
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
GTK_SHADOW_NONE);
label = gtk_label_new (text);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled),
main_vbox);
- gtk_viewport_set_shadow_type (GTK_VIEWPORT (GTK_BIN(scrolled)->child),
+ gtk_viewport_set_shadow_type (GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (scrolled))),
GTK_SHADOW_NONE);
priv->advanced_vbox = main_vbox;
x = widget->allocation.x + indicator_spacing + border_width;
y = widget->allocation.y + (widget->allocation.height - indicator_size) / 2;
- child = GTK_BIN (check_button)->child;
+ child = gtk_bin_get_child (GTK_BIN (check_button));
if (!interior_focus || !(child && gtk_widget_get_visible (child)))
x += focus_width + focus_pad;
/* ellipsize the menu item label, in case the recent document
* display name is huge.
*/
- label = GTK_BIN (item)->child;
+ label = gtk_bin_get_child (GTK_BIN (item));
if (GTK_IS_LABEL (label))
{
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
GtkAdjustment *hadjustment)
{
GtkBin *bin;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
if (hadjustment)
G_CALLBACK (gtk_scrolled_window_adjustment_changed),
scrolled_window);
gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
-
- if (bin->child)
- gtk_widget_set_scroll_adjustments (bin->child,
+
+ child = gtk_bin_get_child (bin);
+ if (child)
+ gtk_widget_set_scroll_adjustments (child,
gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
GtkAdjustment *vadjustment)
{
GtkBin *bin;
+ GtkWidget *child;
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
if (vadjustment)
scrolled_window);
gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
- if (bin->child)
- gtk_widget_set_scroll_adjustments (bin->child,
+ child = gtk_bin_get_child (bin);
+ if (child)
+ gtk_widget_set_scroll_adjustments (child,
gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
GtkBin *bin;
GtkAllocation relative_allocation;
GtkAllocation child_allocation;
+ GtkWidget *child;
gboolean scrollbars_within_bevel;
gint scrollbar_spacing;
guint border_width;
else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
scrolled_window->vscrollbar_visible = FALSE;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
gboolean previous_hvis;
gboolean previous_vvis;
previous_hvis = scrolled_window->hscrollbar_visible;
previous_vvis = scrolled_window->vscrollbar_visible;
- gtk_widget_size_allocate (bin->child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
/* If, after the first iteration, the hscrollbar and the
* vscrollbar flip visiblity, then we need both.
GtkDirectionType direction)
{
GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
+ GtkWidget *child;
gboolean had_focus_child;
had_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget)) != NULL;
-
+
if (scrolled_window->focus_out)
{
scrolled_window->focus_out = FALSE; /* Clear this to catch the wrap-around case */
/* We only put the scrolled window itself in the focus chain if it
* isn't possible to focus any children.
*/
- if (GTK_BIN (widget)->child)
+ child = gtk_bin_get_child (GTK_BIN (widget));
+ if (child)
{
- if (gtk_widget_child_focus (GTK_BIN (widget)->child, direction))
+ if (gtk_widget_child_focus (child, direction))
return TRUE;
}
{
GtkScrolledWindow *scrolled_window;
GtkBin *bin;
+ GtkWidget *child_widget;
bin = GTK_BIN (container);
- g_return_if_fail (bin->child == NULL);
+ child_widget = gtk_bin_get_child (bin);
+ g_return_if_fail (child_widget == NULL);
scrolled_window = GTK_SCROLLED_WINDOW (container);
{
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
g_return_if_fail (child != NULL);
- g_return_if_fail (GTK_BIN (container)->child == child);
+ g_return_if_fail (gtk_bin_get_child (GTK_BIN (container)) == child);
gtk_widget_set_scroll_adjustments (child, NULL, NULL);
{
GtkBin *bin;
GtkWidget *viewport;
+ GtkWidget *child_widget;
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
g_return_if_fail (GTK_IS_WIDGET (child));
g_return_if_fail (child->parent == NULL);
bin = GTK_BIN (scrolled_window);
+ child_widget = gtk_bin_get_child (bin);
- if (bin->child != NULL)
+ if (child_widget)
{
- g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
- g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
+ g_return_if_fail (GTK_IS_VIEWPORT (child_widget));
+ g_return_if_fail (gtk_bin_get_child (GTK_BIN (child_widget)) == NULL);
- viewport = bin->child;
+ viewport = child_widget;
}
else
{
GtkRequisition hscrollbar_requisition;
GtkRequisition vscrollbar_requisition;
GtkRequisition minimum_req, natural_req;
+ GtkWidget *child;
gint min_child_size, nat_child_size;
guint border_width;
&hscrollbar_requisition);
gtk_widget_size_request (scrolled_window->vscrollbar,
&vscrollbar_requisition);
-
- if (bin->child && gtk_widget_get_visible (bin->child))
+
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
- gtk_size_request_get_width (GTK_SIZE_REQUEST (bin->child),
+ gtk_size_request_get_width (GTK_SIZE_REQUEST (child),
&min_child_size,
&nat_child_size);
-
+
if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
{
minimum_req.width += min_child_size;
}
else
{
- GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (child, FALSE);
if (aux_info && aux_info->width > 0)
{
}
else /* GTK_ORIENTATION_VERTICAL */
{
- gtk_size_request_get_height (GTK_SIZE_REQUEST (bin->child),
+ gtk_size_request_get_height (GTK_SIZE_REQUEST (child),
&min_child_size,
&nat_child_size);
-
+
if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
{
minimum_req.height += min_child_size;
}
else
{
- GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
+ GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (child, FALSE);
if (aux_info && aux_info->height > 0)
{
GtkBin *bin;
GtkWindow *window;
GtkContainer *container;
+ GtkWidget *child;
GtkWidget *toplevel;
GtkWidget *old_focus_child;
GtkWidget *parent;
}
/* Now try to focus the first widget in the window */
- if (bin->child)
+ child = gtk_bin_get_child (bin);
+ if (child)
{
- if (gtk_widget_child_focus (bin->child, direction))
+ if (gtk_widget_child_focus (child, direction))
return;
}
}
{
if (gtk_widget_is_drawable (widget))
{
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
GtkButton *button = GTK_BUTTON (widget);
GtkStateType state_type;
GtkShadowType shadow_type;
gtk_tool_button_construct_contents (GtkToolItem *tool_item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (tool_item);
+ GtkWidget *child;
GtkWidget *label = NULL;
GtkWidget *icon = NULL;
GtkToolbarStyle style;
button->priv->label_widget);
}
- if (GTK_BIN (button->priv->button)->child)
+ child = gtk_bin_get_child (GTK_BIN (button->priv->button));
+ if (child)
{
/* Note: we are not destroying the label_widget or icon_widget
* here because they were removed from their containers above
*/
- gtk_widget_destroy (GTK_BIN (button->priv->button)->child);
+ gtk_widget_destroy (child);
}
style = gtk_tool_item_get_toolbar_style (GTK_TOOL_ITEM (button));
GtkWidget *box;
guint spacing;
- box = GTK_BIN (button->priv->button)->child;
+ box = gtk_bin_get_child (GTK_BIN (button->priv->button));
if (GTK_IS_BOX (box))
{
gtk_widget_style_get (GTK_WIDGET (button),
gtk_tool_item_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child;
guint border_width;
+ child = gtk_bin_get_child (GTK_BIN (widget));
if (child && gtk_widget_get_visible (child))
{
gtk_widget_size_request (child, requisition);
GtkToolItem *toolitem = GTK_TOOL_ITEM (widget);
GtkAllocation child_allocation;
gint border_width;
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child;
+ child = gtk_bin_get_child (GTK_BIN (widget));
widget->allocation = *allocation;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
- child = GTK_BIN (tool_item)->child;
-
+ child = gtk_bin_get_child (GTK_BIN (tool_item));
if (child)
gtk_widget_set_tooltip_text (child, text);
}
g_return_if_fail (GTK_IS_TOOL_ITEM (tool_item));
- child = GTK_BIN (tool_item)->child;
-
+ child = gtk_bin_get_child (GTK_BIN (tool_item));
if (child)
gtk_widget_set_tooltip_markup (child, markup);
}
if (! tree_column->button)
return;
- hbox = GTK_BIN (tree_column->button)->child;
+ hbox = gtk_bin_get_child (GTK_BIN (tree_column->button));
alignment = tree_column->alignment;
arrow = tree_column->arrow;
- current_child = GTK_BIN (alignment)->child;
+ current_child = gtk_bin_get_child (GTK_BIN (alignment));
/* Set up the actual button */
gtk_alignment_set (GTK_ALIGNMENT (alignment), tree_column->xalign,
GtkBin *bin = GTK_BIN (viewport);
GtkAllocation view_allocation;
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
+ GtkWidget *child;
gdouble old_page_size;
gdouble old_upper;
gdouble old_value;
hadjustment->lower = 0;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
GtkRequisition child_requisition;
- gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ gtk_widget_get_child_requisition (child, &child_requisition);
hadjustment->upper = MAX (child_requisition.width, view_allocation.width);
}
else
GtkBin *bin = GTK_BIN (viewport);
GtkAllocation view_allocation;
GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
+ GtkWidget *child;
viewport_get_view_allocation (viewport, &view_allocation);
vadjustment->lower = 0;
- if (bin->child && gtk_widget_get_visible (bin->child))
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
{
gint natural_height;
-
- gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (bin->child),
- view_allocation.width,
- NULL,
- &natural_height);
+
+ gtk_size_request_get_height_for_width (GTK_SIZE_REQUEST (child),
+ view_allocation.width,
+ NULL,
+ &natural_height);
vadjustment->upper = MAX (natural_height, view_allocation.height);
}
else
GtkBin *bin = GTK_BIN (widget);
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
- guint border_width;
-
GtkAllocation view_allocation;
+ GtkWidget *child;
GdkWindowAttr attributes;
gint attributes_mask;
gint event_mask;
+ guint border_width;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
viewport->bin_window = gdk_window_new (viewport->view_window, &attributes, attributes_mask);
gdk_window_set_user_data (viewport->bin_window, viewport);
- if (bin->child)
- gtk_widget_set_parent_window (bin->child, viewport->bin_window);
+ child = gtk_bin_get_child (bin);
+ if (child)
+ gtk_widget_set_parent_window (child, viewport->bin_window);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
{
GtkBin *bin = GTK_BIN (container);
- g_return_if_fail (bin->child == NULL);
+ g_return_if_fail (gtk_bin_get_child (bin) == NULL);
gtk_widget_set_parent_window (child, GTK_VIEWPORT (bin)->bin_window);
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
GtkAllocation child_allocation;
+ GtkWidget *child;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
child_allocation.width,
child_allocation.height);
}
- if (bin->child && gtk_widget_get_visible (bin->child))
- gtk_widget_size_allocate (bin->child, &child_allocation);
+
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child))
+ gtk_widget_size_allocate (child, &child_allocation);
gtk_adjustment_changed (hadjustment);
gtk_adjustment_changed (vadjustment);
{
GtkViewport *viewport = GTK_VIEWPORT (data);
GtkBin *bin = GTK_BIN (data);
+ GtkWidget *child;
- if (bin->child && gtk_widget_get_visible (bin->child) &&
+ child = gtk_bin_get_child (bin);
+ if (child && gtk_widget_get_visible (child) &&
gtk_widget_get_realized (GTK_WIDGET (viewport)))
{
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
static void
gtk_window_map (GtkWidget *widget)
{
+ GtkWidget *child;
GtkWindow *window = GTK_WINDOW (widget);
GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
GdkWindow *toplevel;
gtk_widget_set_mapped (widget, TRUE);
- if (window->bin.child &&
- gtk_widget_get_visible (window->bin.child) &&
- !gtk_widget_get_mapped (window->bin.child))
- gtk_widget_map (window->bin.child);
+ child = gtk_bin_get_child (&(window->bin));
+ if (child &&
+ gtk_widget_get_visible (child) &&
+ !gtk_widget_get_mapped (child))
+ gtk_widget_map (child);
if (window->frame)
toplevel = window->frame;
{
GtkWindow *window;
GtkAllocation child_allocation;
+ GtkWidget *child;
guint border_width;
window = GTK_WINDOW (widget);
widget->allocation = *allocation;
- if (window->bin.child && gtk_widget_get_visible (window->bin.child))
+ child = gtk_bin_get_child (&(window->bin));
+ if (child && gtk_widget_get_visible (child))
{
border_width = gtk_container_get_border_width (GTK_CONTAINER (window));
child_allocation.x = border_width;
child_allocation.height =
MAX (1, (gint)allocation->height - child_allocation.y * 2);
- gtk_widget_size_allocate (window->bin.child, &child_allocation);
+ gtk_widget_size_allocate (child, &child_allocation);
}
if (gtk_widget_get_realized (widget) && window->frame)
GtkBin *bin;
GtkWindow *window;
GtkContainer *container;
+ GtkWidget *child;
GtkWidget *old_focus_child;
GtkWidget *parent;
}
/* Now try to focus the first widget in the window */
- if (bin->child)
+ child = gtk_bin_get_child (bin);
+ if (child)
{
- if (gtk_widget_child_focus (bin->child, direction))
+ if (gtk_widget_child_focus (child, direction))
return TRUE;
}
g_assert (strcmp (GTK_WIDGET (menu)->name, "file") == 0);
g_list_free (children);
- label = G_OBJECT (GTK_BIN (menu)->child);
+ label = G_OBJECT (gtk_bin_get_child (GTK_BIN (menu)));
g_assert (GTK_IS_LABEL (label));
g_assert (strcmp (gtk_label_get_text (GTK_LABEL (label)), "File") == 0);
g_assert (strcmp (GTK_WIDGET (menu)->name, "file") == 0);
g_list_free (children);
- label = G_OBJECT (GTK_BIN (menu)->child);
+ label = G_OBJECT (gtk_bin_get_child (GTK_BIN (menu)));
g_assert (label != NULL);
g_assert (GTK_IS_LABEL (label));
g_assert (strcmp (gtk_label_get_text (GTK_LABEL (label)), "File") == 0);
g_assert (strcmp (GTK_WIDGET (menu)->name, "file") == 0);
g_list_free (children);
- label = G_OBJECT (GTK_BIN (menu)->child);
+ label = G_OBJECT (gtk_bin_get_child (GTK_BIN (menu)));
g_assert (label != NULL);
g_assert (GTK_IS_LABEL (label));
g_assert (strcmp (gtk_label_get_text (GTK_LABEL (label)), "File") == 0);
"<object class=\"GtkAccelGroup\" id=\"accelgroup1\"/>"
"</interface>";
GtkBuilder *builder;
+ GtkWidget *child;
GtkWidget *window, *item;
GtkAccelGroup *accel_group;
GtkWidget *item_accel_label, *sample_accel_label, *sample_menu_item, *custom;
sample_menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_NEW, accel_group);
- g_assert (GTK_BIN (sample_menu_item)->child);
- g_assert (GTK_IS_ACCEL_LABEL (GTK_BIN (sample_menu_item)->child));
- sample_accel_label = GTK_WIDGET (GTK_BIN (sample_menu_item)->child);
+ child = gtk_bin_get_child (GTK_BIN (sample_menu_item));
+ g_assert (child);
+ g_assert (GTK_IS_ACCEL_LABEL (child));
+ sample_accel_label = child;
gtk_widget_show (sample_accel_label);
- g_assert (GTK_BIN (item)->child);
- g_assert (GTK_IS_ACCEL_LABEL (GTK_BIN (item)->child));
- item_accel_label = GTK_WIDGET (GTK_BIN (item)->child);
+ child = gtk_bin_get_child (GTK_BIN (item));
+ g_assert (child);
+ g_assert (GTK_IS_ACCEL_LABEL (child));
+ item_accel_label = child;
gtk_accel_label_refetch (GTK_ACCEL_LABEL (sample_accel_label));
gtk_accel_label_refetch (GTK_ACCEL_LABEL (item_accel_label));
gboolean expanded;
gboolean simsuccess;
gtk_container_add (GTK_CONTAINER (expander), label);
- gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), expander);
+ gtk_container_add (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (window))), expander);
gtk_widget_show (expander);
gtk_widget_show (label);
gtk_widget_show_now (window);
gboolean expanded;
gboolean simsuccess;
gtk_container_add (GTK_CONTAINER (expander), entry);
- gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), expander);
+ gtk_container_add (GTK_CONTAINER (gtk_bin_get_child (GTK_BIN (window))), expander);
gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE);
gtk_widget_show (expander);
gtk_widget_show (entry);
static void
test_slider_ranges (void)
{
+ GtkWidget *child;
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test: gtk_test_warp_slider");
GtkWidget *hscale = gtk_hscale_new_with_range (-50, +50, 5);
- gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), hscale);
+
+ child = gtk_bin_get_child (GTK_BIN (window));
+ gtk_container_add (GTK_CONTAINER (child), hscale);
gtk_widget_show (hscale);
gtk_widget_show_now (window);
while (gtk_events_pending ())
{
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test: test_xserver_sync");
GtkWidget *darea = gtk_drawing_area_new ();
+ GtkWidget *child;
GTimer *gtimer = g_timer_new();
gint sync_is_slower = 0, repeat = 5;
+
+ child = gtk_bin_get_child (GTK_BIN (window));
gtk_widget_set_size_request (darea, 320, 200);
- gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), darea);
+ gtk_container_add (GTK_CONTAINER (child), darea);
gtk_widget_show (darea);
gtk_widget_show_now (window);
while (repeat--)
static void
test_spin_button_arrows (void)
{
+ GtkWidget *child;
GtkWidget *window = gtk_test_create_simple_window ("Test Window", "Test: test_spin_button_arrows");
GtkWidget *spinner = gtk_spin_button_new_with_range (0, 100, 5);
gboolean simsuccess;
double oldval, newval;
- gtk_container_add (GTK_CONTAINER (GTK_BIN (window)->child), spinner);
+
+ child = gtk_bin_get_child (GTK_BIN (window));
+ gtk_container_add (GTK_CONTAINER (child), spinner);
gtk_widget_show (spinner);
gtk_widget_show_now (window);
gtk_test_slider_set_perc (spinner, 0);
if (!status_window->window)
status_window_make_window (status_window);
- label = GTK_BIN (status_window->window)->child;
+ label = gtk_bin_get_child (GTK_BIN (status_window->window));
gtk_label_set_text (GTK_LABEL (label), text);
gtk_widget_show (status_window->window);
gboolean ret = FALSE;
const gchar *parent_type_name;
- child = GTK_BIN (widget)->child;
+ child = gtk_bin_get_child (GTK_BIN (widget));
if (GTK_IS_ARROW (child))
{
g_object_get (child,
{
GtkWidget *temp_widget;
- temp_widget = GTK_BIN (list->data)->child;
+ temp_widget = gtk_bin_get_child (GTK_BIN (list->data));
if (GTK_IS_BUTTON (temp_widget))
mnemonic_widget = temp_widget;
}
* we get here.
*/
key = NULL;
- child = GTK_BIN (item)->child;
+ child = gtk_bin_get_child (GTK_BIN (item));
if (GTK_IS_ACCEL_LABEL (child))
{
GtkAccelLabel *accel_label;
static gboolean
is_attached_menu_window (GtkWidget *widget)
{
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child;
gboolean ret = FALSE;
+ child = gtk_bin_get_child (GTK_BIN (widget));
if (GTK_IS_MENU (child))
{
GtkWidget *attach;
static gboolean
is_combo_window (GtkWidget *widget)
{
- GtkWidget *child = GTK_BIN (widget)->child;
+ GtkWidget *child;
AtkObject *obj;
GtkAccessible *accessible;
+ child = gtk_bin_get_child (GTK_BIN (widget));
+
if (!GTK_IS_EVENT_BOX (child))
return FALSE;
- child = GTK_BIN (child)->child;
+ child = gtk_bin_get_child (GTK_BIN (child));
if (!GTK_IS_FRAME (child))
return FALSE;
- child = GTK_BIN (child)->child;
+ child = gtk_bin_get_child (GTK_BIN (child));
if (!GTK_IS_SCROLLED_WINDOW (child))
return FALSE;
bool_changed (GObject *object, GParamSpec *pspec, gpointer data)
{
GtkToggleButton *tb = GTK_TOGGLE_BUTTON (data);
+ GtkWidget *child;
GValue val = { 0, };
g_value_init (&val, G_TYPE_BOOLEAN);
unblock_controller (G_OBJECT (tb));
}
- gtk_label_set_text (GTK_LABEL (GTK_BIN (tb)->child), g_value_get_boolean (&val) ?
- "TRUE" : "FALSE");
+ child = gtk_bin_get_child (GTK_BIN (tb));
+ gtk_label_set_text (GTK_LABEL (child),
+ g_value_get_boolean (&val) ? "TRUE" : "FALSE");
g_value_unset (&val);
}
current_page = gtk_assistant_get_current_page (GTK_ASSISTANT (assistant));
page = gtk_assistant_get_nth_page (GTK_ASSISTANT (assistant), current_page);
- progress = GTK_BIN (page)->child;
+ progress = gtk_bin_get_child (GTK_BIN (page));
value = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (progress));
value += 0.1;
{
GtkWidget *progress;
- progress = GTK_BIN (page)->child;
+ progress = gtk_bin_get_child (GTK_BIN (page));
gtk_assistant_set_page_complete (GTK_ASSISTANT (widget), page, FALSE);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 0.0);
gdk_threads_add_timeout (300, (GSourceFunc) progress_timeout, widget);
g_signal_connect (drawing_area, "unrealize",
G_CALLBACK (on_rotated_text_unrealize), NULL);
- gtk_widget_show_all (GTK_BIN (window)->child);
+ gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (window)));
gtk_widget_set_size_request (drawing_area, DEFAULT_TEXT_RADIUS * 2, DEFAULT_TEXT_RADIUS * 2);
gtk_widget_size_request (window, &requisition);
size_group_hsize_changed (GtkSpinButton *spin_button,
GtkWidget *button)
{
- gtk_widget_set_size_request (GTK_BIN (button)->child,
+ gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
gtk_spin_button_get_value_as_int (spin_button),
-1);
}
size_group_vsize_changed (GtkSpinButton *spin_button,
GtkWidget *button)
{
- gtk_widget_set_size_request (GTK_BIN (button)->child,
+ gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (button)),
-1,
gtk_spin_button_get_value_as_int (spin_button));
}
gtk_size_group_add_widget (master_size_group, main_button);
gtk_size_group_add_widget (hgroup1, main_button);
gtk_size_group_add_widget (vgroup1, main_button);
- gtk_widget_set_size_request (GTK_BIN (main_button)->child,
+ gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (main_button)),
SIZE_GROUP_INITIAL_SIZE,
SIZE_GROUP_INITIAL_SIZE);
font_desc = pango_font_description_from_string ("Helvetica,Sans Oblique 18");
button = gtk_button_new_with_label ("Some Text");
- gtk_widget_modify_font (GTK_BIN (button)->child, font_desc);
+ gtk_widget_modify_font (gtk_bin_get_child (GTK_BIN (button)),
+ font_desc);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Foreground:");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Some Text");
- gtk_widget_modify_fg (GTK_BIN (button)->child, GTK_STATE_NORMAL, &red);
+ gtk_widget_modify_fg (gtk_bin_get_child (GTK_BIN (button)),
+ GTK_STATE_NORMAL, &red);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Background:");
rc_style->ythickness = 5;
gtk_widget_modify_style (button, rc_style);
- gtk_widget_modify_style (GTK_BIN (button)->child, rc_style);
+ gtk_widget_modify_style (gtk_bin_get_child (GTK_BIN (button)), rc_style);
g_object_unref (rc_style);
GtkPackDirection child_pack_dir,
gdouble angle)
{
+ GtkWidget *child;
GtkWidget *menubar;
GtkWidget *menuitem;
GtkWidget *menu;
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_HOME, NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
- gtk_label_set_angle (GTK_LABEL (GTK_BIN (menuitem)->child), angle);
+ child = gtk_bin_get_child (GTK_BIN (menuitem));
+ gtk_label_set_angle (GTK_LABEL (child), angle);
menu = create_menu (2);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
menuitem = gtk_menu_item_new_with_label ("foo");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
- gtk_label_set_angle (GTK_LABEL (GTK_BIN (menuitem)->child), angle);
+ child = gtk_bin_get_child (GTK_BIN (menuitem));
+ gtk_label_set_angle (GTK_LABEL (child), angle);
menu = create_menu (2);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
menuitem = gtk_menu_item_new_with_label ("bar");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
- gtk_label_set_angle (GTK_LABEL (GTK_BIN (menuitem)->child), angle);
+ child = gtk_bin_get_child (GTK_BIN (menuitem));
+ gtk_label_set_angle (GTK_LABEL (child), angle);
menu = create_menu (2);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
G_CALLBACK (get_screen_response), display_entry);
gtk_widget_grab_focus (display_entry);
- gtk_widget_show_all (GTK_BIN (dialog)->child);
+ gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (dialog)));
while (!correct_second_display)
{
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic ("<b>_Futz!!</b>");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
- gtk_label_set_use_markup (GTK_LABEL (GTK_BIN (button)->child), TRUE);
+ gtk_label_set_use_markup (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), TRUE);
g_signal_connect (button, "clicked", G_CALLBACK (futz), NULL);
g_signal_connect (button, "realize", G_CALLBACK (gtk_widget_grab_focus), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 400);
projects / gtk4.git / commitdiff